import _ from 'lodash'
import {
	SelectPages
} from '../config/router-config'

export const SELECT_PAGE_TYPE = {
	dept: {
		text: '科室',
		num: 0
	},
	user: {
		text: '人',
		num: 0
	},
	team: {
		text: '小组',
		num: 0
	},
	dic: {
		text: '种',
		num: 0
	}
}
/**
 * 计算选中不同类型的数据
 * 比如 科室 小组 人员
 * @param {*} arr 
 */
export function selectedTypeNumComputed(arr, sourceData = []) {
	const filterValue = _.filter(sourceData, item => _.includes(arr, item._value))
	const selected = {
		dept: {
			text: '科室',
			num: 0
		},
		user: {
			text: '人',
			num: 0
		},
		team: {
			text: '小组',
			num: 0
		},
		dic: {
			text: '种',
			num: 0
		}
	}
	for (let i of filterValue) {
		selected[i._key].num += 1

	}
	return selected
}

/**
 * 处理checkbox值选中
 * @param {*} checkValue 选择的值
 * @param {*} isCheck  是否选中
 * @param {*} originList  已选择值的列表
 */
export function handleCheckBoxChecked(checkValue, isCheck, originList) {
	// console.log(originList, 'originList');
	const index = _.indexOf(originList, checkValue)
	//  存在
	if (index > -1) {
		//  取消选中情况
		if (!isCheck) {
			originList.splice(index, 1)
		}
	} else {
		originList.push(checkValue)
	}
	return originList
}

/**
 * 处理选中 用于selectedPopup组件
 * @param {*} sourceData  源数据
 * @param {*} val  选择的值
 */
export function handleSelectedPopup(sourceData, val) {
	const filterList = _.filter(sourceData, (item) => _.includes(val, item._value))
	let selectedPopupList = {}
	for (let i of filterList) {
		const {
			_key,
			_name,
			_value
		} = i
		selectedPopupList[_key] = selectedPopupList[_key] || [];
		selectedPopupList[_key].push({
			name: _name,
			value: _value,
			key: _key
		});
	}
	return selectedPopupList
}

/**
 * 平铺tree
 * @param {*} tree 
 */
export function flattenTree(tree) {
	const result = [];

	function traverse(node) {

		for (const child of node) {
			result.push(child);
			if (child.children && child.children.length > 0) {
				traverse(child.children);
			}
		}
	}
	traverse(tree);
	return result;

}
/**
 * 将 map 结构转为平铺结构
 */
export function mapToArr(obj) {
	let arr = []
	for (let i in obj) {
		arr = [...arr, ...obj[i]]
	}
	return arr
}
/**
 * 获取每个键对应数组的长度并计算总和
 * @param {*} obj 
 */
export function keyArrLength(obj) {
	let totalLength = 0;
	for (const key in obj) {
		if (obj.hasOwnProperty(key)) {
			const arr = obj[key];
			const length = arr.length;
			totalLength += length;
		}
	}
	return totalLength
}

export function queryParams(data = {}, isPrefix = true, arrayFormat = 'brackets') {
	const prefix = isPrefix ? '?' : ''
	const _result = []
	if (['indices', 'brackets', 'repeat', 'comma'].indexOf(arrayFormat) == -1) arrayFormat = 'brackets'
	for (const key in data) {
		const value = data[key]
		// 去掉为空的参数
		if (['', undefined, null].indexOf(value) >= 0) {
			continue
		}
		// 如果值为数组，另行处理
		if (value.constructor === Array) {
			// e.g. {ids: [1, 2, 3]}
			switch (arrayFormat) {
				case 'indices':
					// 结果: ids[0]=1&ids[1]=2&ids[2]=3
					for (let i = 0; i < value.length; i++) {
						_result.push(`${key}[${i}]=${value[i]}`)
					}
					break
				case 'brackets':
					// 结果: ids[]=1&ids[]=2&ids[]=3
					value.forEach((_value) => {
						_result.push(`${key}[]=${_value}`)
					})
					break
				case 'repeat':
					// 结果: ids=1&ids=2&ids=3
					value.forEach((_value) => {
						_result.push(`${key}=${_value}`)
					})
					break
				case 'comma':
					// 结果: ids=1,2,3
					let commaStr = ''
					value.forEach((_value) => {
						commaStr += (commaStr ? ',' : '') + _value
					})
					_result.push(`${key}=${commaStr}`)
					break
				default:
					value.forEach((_value) => {
						_result.push(`${key}[]=${_value}`)
					})
			}
		} else {
			_result.push(`${key}=${value}`)
		}
	}
	return _result.length ? prefix + _result.join('&') : ''
}

export const DeptSelectChoseType = {
	/**
	 * 选择科室
	 */
	selectDept: 'selectDept',
	/**
	 * 选择科室-小组-人
	 */
	selectDeptTeamUser: 'selectDeptTeamUser',
	/**
	 * 选择小组-人
	 */
	selectTeamUser: 'selectTeamUser'
}

/**
 * 跳转至选择科室页面
 * @param {*} backToPath 
 * @param {*} storeKey 
 * @param {*} choseType    selectDept,selectDeptTeamUser,selectTeamUser
 * @param {*} multiple 
 */
export function toDeptSelectPage(storeKey, choseType, multiple = true) {
	// console.log(getCurrentPage(), 'getCurrentPage()');
	const params = {
		backToPath: getCurrentPage(),
		storeKey,
		choseType,
		multiple
	}
	if (!choseType) {
		console.error(`choseType is undefined`);
		return
	}
	uni.navigateTo({
		url: `${SelectPages.SELECT_DEPT.router}${queryParams(params)}`,
	})

}
/**
 * 跳转至选择小组页面
 */
export function toTeamSelectPage(storeKey, multiple = true) {
	const params = {
		backToPath: getCurrentPage(),
		storeKey,
		multiple
	}

	uni.navigateTo({
		url: `${SelectPages.SELECT_TEAM.router}${queryParams(params)}`,
	})
}
/**
 * 跳转至选择小组/人员页面
 */
export function toTeamUserSelectPage(storeKey, multiple = false) {
	const params = {
		backToPath: getCurrentPage(),
		storeKey,
		multiple
	}

	uni.navigateTo({
		url: `${SelectPages.SELECT_TEAM_USER.router}${queryParams(params)}`,
	})
}

/**
 * 跳转至人员选择页面
 * @param {*} backToPath 
 * @param {*} key 
 * @param {*} multiple 
 */
export function toUserSelectPage(storeKey, multiple = true) {
	const params = {
		backToPath: getCurrentPage(),
		storeKey,
		multiple
	}
	wx.navigateTo({
		url: `${SelectPages.SELECT_USER.router}${queryParams(params)}`,
	})
}

/**
 * 跳转至字典选择页面
 * @param {*} backToPath 
 * @param {*} key 
 * @param {*} multiple 
 */
export function toDicSelectPage(storeKey, dicKey, multiple = true) {
	const params = {
		backToPath: getCurrentPage(),
		dicKey,
		storeKey,
		multiple
	}
	wx.navigateTo({
		url: `${SelectPages.SELECT_DIC.router}${queryParams(params)}`,
	})
}

// 获取当前页面路径
export function getCurrentPage() {
	const pages = getCurrentPages();
	const currentPage = pages[pages.length - 1];
	const url = `/${currentPage.route}`;
	return url
}

/**
 * 将扁平数据转换成树形数据
 * @param data
 * @param config
 * @returns {unknown[]}
 */
export function convertToTree(data, config = {
	id: 'deptId',
	parentId: 'parentId',
	name: 'name'
}) {
	const tree = {};
	const map = {};
	const arr = JSON.parse(JSON.stringify(data));
	arr.forEach((item) => {
		const id = item[config.id];
		const pid = item[config.parentId];
		Object.assign(item, {
			_path: item[config.name]
		})
		map[id] = item;
		if (pid !== 0 && pid) {
			const parent = map[pid];
			if (parent) {
				parent['children'] = parent.children || [];
				const parentPath = parent._path || '';
				const path = `${parentPath}/${item[config.name]}`;
				Object.assign(item, {
					_path: path
				})
				parent.children.push(item);
			}
		} else {
			tree[id] = item;
		}
	});
	if (_.isEmpty(tree)) {
		return Object.values(map);
	}
	return Object.values(tree);
}

// 排除指定value 的数据
export const pullValue = (arr, values) => {
	return _.pullAllWith(arr, values, (item, f) => {
		return item.dictValue === f
	})
}

// 获取指定key 的数据
export const getDicValue = (dicList, dicKey) => {
	const findData = _.find(dicList, {
		type: dicKey
	})
	if (findData) {
		return _.map(findData.data, item => {
			return {
				...item,
				value: item.dictValue,
				label: item.dictLabel
			}
		})
	}
	return []
}

// 处理自定义选择的value
export const customValue = (val) => {
	const v = val.split('-')
	if (v.length) {
		return {
			value: v[1],
			prefix: v[0]
		}
	}
	return {
		value: null,
		prefix: null
	}
}
/**
 * 设计稿宽度
 */
export const DESIGN_WIDTH = 750;
//获取节点高度
export function getElHeightRpx(targetEl, callback) {
	console.log(uni.createSelectorQuery().select(targetEl));
	uni.createSelectorQuery().select(targetEl).boundingClientRect(function(rect) {
		const {
			height,
			width
		} = rect
		let ratio = DESIGN_WIDTH / width
		callback(height * ratio)
	}).exec()
}

// 获取视口高度
export function getViewHeight(callback, unit = "rpx" || "px") {
	uni.getSystemInfo({
		success: (result) => {
			console.log(result, '=====result====');
			// 获取可使用窗口宽度
			let clientHeight = result.windowHeight;
			// 获取可使用窗口高度
			let clientWidth = result.windowWidth;
			// 算出比例
			let ratio = DESIGN_WIDTH / clientWidth;
			// 算出高度(单位rpx)
			let height = clientHeight * ratio;
			if (callback) {
				if (unit === 'px') {
					callback(clientHeight)
				} else {
					callback(height)
				}
			}

		},
	})
}
/**
 * 获取文件后缀
 */
export function getSuffix(fileName) {
	if (fileName) {
		const suffix_reg = /\.([0-9a-z]+)(?:[\?#]|$)/i;
		return fileName.match(suffix_reg)[1];
	}
	return '';
}
export function base64ToFile(base64) {
	// 将base64按照 , 进行分割 将前缀  与后续内容分隔开
	let data = base64.split(',');
	// 利用正则表达式 从前缀中获取图片的类型信息（image/png、image/jpeg、image/webp等）
	let type = data[0].match(/:(.*?);/)[1];
	// 从图片的类型信息中 获取具体的文件格式后缀（png、jpeg、webp）
	let suffix = type.split('/')[1];
	// 使用atob()对base64数据进行解码  结果是一个文件数据流 以字符串的格式输出
	const bstr = window.atob(data[1]);
	// 获取解码结果字符串的长度
	let n = bstr.length
	// 根据解码结果字符串的长度创建一个等长的整形数字数组
	// 但在创建时 所有元素初始值都为 0
	const u8arr = new Uint8Array(n)
	// 将整形数组的每个元素填充为解码结果字符串对应位置字符的UTF-16 编码单元
	while (n--) {
		// charCodeAt()：获取给定索引处字符对应的 UTF-16 代码单元
		u8arr[n] = bstr.charCodeAt(n)
	}
	// 利用构造函数创建File文件对象
	// new File(bits, name, options)
	const file = new File([u8arr], `${Date.now()}.${suffix}`, {
		type: type
	})
	// 将File文件对象返回给方法的调用者
	return file;
}

/**
 * 提取base64 数据中的文件类型
 */
export function extractFileType(base64Data) {
	const regex = /^data:([a-zA-Z]+\/[a-zA-Z]+);base64,/;
	const match = base64Data.match(regex);
	console.log(match);
	if (match && match[1]) {
		return match[1].split('/')[1];
	} else {
		console.error('Unable to extract file type from Base64 data');
		return null;
	}
}
import dayjs from "dayjs"
export function dateFormatter(time, format = 'YYYY-MM-DD') {
	return dayjs(time).format(format)
}